home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part2 / 15515 < prev    next >
Encoding:
Text File  |  1996-08-05  |  2.6 KB  |  85 lines
  1. Path: news.rchland.ibm.com!usenet
  2. From: Philip Staite <pstaite+@rchland.ibm.com>
  3. Newsgroups: comp.lang.c++
  4. Subject: Re: inheritance of friendship
  5. Date: Fri, 05 Apr 1996 16:18:26 -0600
  6. Organization: IBM Rochester, MN
  7. Message-ID: <31659C32.41C6@rchland.ibm.com>
  8. References: <4k3ge2$igu@panoramix.fi.upm.es>
  9. NNTP-Posting-Host: powertool.rchland.ibm.com
  10. Mime-Version: 1.0
  11. Content-Type: text/plain; charset=us-ascii
  12. Content-Transfer-Encoding: 7bit
  13. X-Mailer: Mozilla 2.01 (X11; I; AIX 1)
  14.  
  15. Sacha wrote:
  16. > 
  17. > I've just read in the FAQ that friendship isn't inherited: that is if B is a
  18. > friend of class A, and class C is derived from B, C ISN'T a friend of A.
  19. > 
  20. >         A     friends with B
  21. >                            |
  22. >           not friends with C
  23. > 
  24. > Is there some way around this?
  25. > 
  26. > I am overloading << to output to streams, but I don't want to have to rewrite the
  27. > same function for each different type of stream. I've tried making both B and C
  28. > friends of A and defining the function for B, but this doesn't work.
  29. > 
  30. > Should I just forget about overloading << and write an outToStream function
  31. > instead?
  32.  
  33. I'm not sure exactly what you're trying to do, but here are a couple of
  34. examples of what you _can_ do...
  35.  
  36.  
  37. class foo {
  38.   public:
  39.     friend ostream& operator<<( ostream&, const foo& );
  40. };
  41.  
  42. Now, this friend function provides stream io to *any* kind of ostream
  43. for class foo.  That is, you can stream out to the console cout, a file
  44. via an ofstream, an in-memory buffer via an ostrstream, etc.
  45.  
  46.  
  47. OTOH, maybe you want to do something like:
  48.  
  49. class foo {
  50.   public:
  51.     virtual ~foo() {}  // always if deriving!!!
  52.     inline friend ostream& operator<<( ostream&, const foo& );
  53.   protected:
  54.     virtual ostream& virtOut( ostream& ) const;
  55. };
  56.  
  57. ostream& operator<<( ostream& o, const foo& f ) {
  58.     return f.virtOut( o ); }
  59.  
  60. ostream& foo::virtOut( ostream& o ) const {
  61.     return o << "I'm a foo!"; }
  62.  
  63. class bar : public foo {
  64.   protected:
  65.     virtual ostream& virtOut( ostream& ) const;
  66. };
  67.  
  68. ostream& bar::virtOut( ostream& o ) const {
  69.     return o << "I'm a bar!"; }
  70.  
  71.  
  72. Now, each derived class of foo gets to define its own virtOut() function
  73. and that is the one that is used when an object is streamed out.  All <<
  74. operations go through the base class where they pick up virtual function
  75. dispatch... (very handy actually)  BTW, now each derived class controls
  76. it's streaming, *and* it can be streamed to any ostream, cout, ofstream,
  77. ostrstream...  See why streams are so much more powerful than printf()
  78. ???
  79.  
  80.  
  81. -- 
  82.  
  83. Phil Staite, (507) 253-2529, team OS/2
  84. internet: pstaite@vnet.ibm.com  internal: pstaite@rchland
  85.